package cn.com.cifi.mars.util;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

import org.apache.commons.lang.StringUtils;

import cn.com.cifi.mars.bean.vo.monitoringConsole.OrgRoundVo;
import cn.com.cifi.mars.constant.Constants;
import cn.com.cifi.mars.constant.VersionTypeEunm;
import lombok.extern.slf4j.Slf4j;

/**
 * 字符串工具类
 */
@Slf4j
public class StrUtils {

    /**
     * 逗号（,）
     */
    public static final String DELIMIT_COMMA = ",";
    /**
     * 英文句号（.）
     */
    public static final String DELIMIT_STOP = ".";
    /**
     * （“”）空字符串
     */
    private static final String BLANK_STRING = "";

    /**
     * 判断是否为null 或空字符串 或字符串中全是空格 或字符串("null").
     * <p>
     * <pre>
     * StrUtils.isEmpty(null)      = true
     * StrUtils.isEmpty("")        = true
     * StrUtils.isEmpty(" ")       = true
     * StrUtils.isEmpty("null")    = true
     * StrUtils.isEmpty("NULL")    = false
     * StrUtils.isEmpty(" null ")  = false
     * </pre>
     *
     * @param s 字符串
     * @return 是 true；否 false 。
     */
    public static boolean isEmpty(final String s) {
        if (s == null) {
            return true;
        }
        return (s.isEmpty() || s.trim().length() == 0) || "null".equals(s);
    }

    /**
     * 判断是否为非null 或非空字符串 或字符串中包含非空格字符 或非字符串("null").
     * <p>
     * <pre>
     * StrUtils.isNotEmpty(null)      = false
     * StrUtils.isNotEmpty("")        = false
     * StrUtils.isNotEmpty(" ")       = false
     * StrUtils.isNotEmpty("null")    = false
     * StrUtils.isNotEmpty("NULL")    = true
     * StrUtils.isNotEmpty(" null ")  = true
     * </pre>
     *
     * @param s 字符串
     * @return 是 true； 否 false 。
     */
    public static boolean isNotEmpty(final String s) {
        return !isEmpty(s);
    }

    /**
     * 按分隔符将字符串组装为字符串数组.</br>
     * 如果传入参数为null或空串，直接返回空数组。
     * <p>
     * <pre>
     * StrUtils.split("",",")          = {}
     * StrUtils.split("null,b",",")    = {"null","b"}
     * StrUtils.split("1,2,3,a,b",",") = {"1","2","3","a","b"}
     * </pre>
     *
     * @param s         待分割字符串
     * @param delimiter 分割符
     * @return 字符串数组
     */
    public static String[] split(String s, String delimiter) {
        if (isNotEmpty(s)) {
            return s.split(delimiter);
        }
        return new String[]{};
    }

    /**
     * 按逗号分隔符（“,”）将字符串组装为字符串List集合.</br>
     * 如果传入参数为null或空串，直接返回空List。</br>
     * PS:按10进制转换字符串
     * <p>
     * <pre>
     * StrUtils.extractIntegerList(null)               = {}
     * StrUtils.extractIntegerList(" ")                = {}
     * StrUtils.extractIntegerList(",bob,1,2,3,4,a,5") = {1,2,3,4,5}
     * </pre>
     *
     * @param str 待分割字符串
     * @return List&lt;Integer&gt;
     */
    public static List<Integer> extractIntegerList(String str) {
        List<Integer> list = new ArrayList<Integer>();
        if (str == null) {
            return list;
        }
        String[] strArr = str.split(DELIMIT_COMMA);
        for (String s : strArr) {
            for (char cs : s.toCharArray()) {
                // 包含非空格字符
                if (cs > '9' || cs < '0') {
                    break;
                }
            }
            try {
                list.add(Integer.parseInt(s, 10));
            } catch (Exception e) {
                continue;
            }
        }
        return list;
    }

    /**
     * 按逗号分隔符（“,”）将字符串组装为字符串List集合.</br>
     * 如果传入参数为null或空串，直接返回空List。</br>
     * PS:按10进制转换字符串
     * <p>
     * <pre>
     * StrUtils.extractLongList(null)               = {}
     * StrUtils.extractLongList(" ")                = {}
     * StrUtils.extractLongList(",bob,1,2,3,4,a,5") = {1,2,3,4,5}
     * </pre>
     *
     * @param str 待分割字符串
     * @return List&lt;Long&gt;
     */
    public static List<Long> extractLongList(String str) {
        List<Long> list = new ArrayList<Long>();
        if (str == null) {
            return list;
        }
        String[] strArr = str.split(DELIMIT_COMMA);
        for (String s : strArr) {
            for (char cs : s.toCharArray()) {
                // 包含非空格字符
                if (cs > '9' || cs < '0') {
                    break;
                }
            }
            try {
                list.add(Long.parseLong(s, 10));
            } catch (Exception e) {
                continue;
            }
        }
        return list;
    }

    /**
     * 按分隔符将字符串组装为字符串List集合.</br>
     * 如果传入参数为null或空串，直接放回空List。
     * <p>
     * <pre>
     * StrUtils.splitToStringList(null)            = {}
     * StrUtils.splitToStringList(" ")             = {}
     * StrUtils.splitToStringList(",bob,1,null,5") = {"","bob","1","null","5"}
     * </pre>
     *
     * @param str       待分割字符串
     * @param delimiter 分割符
     * @return List&lt;String&gt;
     */
    public static List<String> splitToStringList(String str, String delimiter) {
        List<String> list = new ArrayList<String>();
        if (str == null) {
            return list;
        }
        String[] sArr = split(str, delimiter);
        for (int i = 0; i < sArr.length; i++) {
            list.add(sArr[i]);
        }
        return list;
    }

    /**
     * 连接返回字符串.
     * <p>
     * <pre>
     * StrUtils.join({"hello"," ","world","!"},"")  = "hello world!"
     * StrUtils.join({"hello"," ","world","!"},",") = "hello, ,world,!"
     * </pre>
     *
     * @param collection 待连接成字符串的集合
     * @param separator  连接符
     * @return String
     */
    public static String join(Collection<?> collection, String separator) {
        return join(collection, separator, BLANK_STRING, BLANK_STRING);
    }

    /**
     * 连接返回字符串并添加前缀和后缀.
     * <p>
     * <pre>
     * StrUtils.join({"hello"," ","world","!"},",","p","s") = "phellos,p s,pworlds,p!s"
     * </pre>
     *
     * @param collection 待连接成字符串的集合
     * @param separator  连接符
     * @param prefix     前缀，添加到每个集合元素前
     * @param suffix     后缀，添加到每个集合元素后
     * @return String
     */
    public static String join(Collection<?> collection, String separator, String prefix, String suffix) {
        if (collection == null || collection.isEmpty()) {
            return BLANK_STRING;
        }
        StringBuilder sb = new StringBuilder();
        Iterator<?> it = collection.iterator();
        while (it.hasNext()) {
            sb.append(prefix).append(it.next()).append(suffix);
            if (it.hasNext()) {
                sb.append(separator);
            }
        }
        return sb.toString();
    }

    /**
     * 高亮处理当前匹配的关键词.</br>
     * PS: 给keyword添加&lt;em&gt;标签。
     * <p>
     * <pre>
     * StrUtils.highLightHtml("hello world!","hello")       = "&lt;em&gt;hello&lt;/em&gt; world!"
     * --> <em>hello</em> world!
     * StrUtils.highLightHtml("hello world!","hello|world") = "&lt;em&gt;hello&lt;/em&gt; &lt;em&gt;world&lt;/em&gt;!"
     * --> <em>hello</em> <em>world</em>!
     * </pre>
     *
     * @param content 待高亮处理的文本
     * @param keyword 关键字 (多关键字用"|"分隔 如：张三|李四)
     * @return String
     */
    public static String highlightHtml(String content, String keyword) {
        Pattern p = Pattern.compile(keyword);
        Matcher m = p.matcher(content);

        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(sb, "<em>$0</em>");
        }
        m.appendTail(sb);
        return sb.toString();
    }

    /**
     * 判断字符串（str）中是否包含指定字符串（subStr）.
     * <p>
     * <pre>
     * StrUtils.contains(null, "b") = false;
     * StrUtils.contains("bob!", null) = false;
     * StrUtils.contains("bob!", "a") = false;
     * StrUtils.contains("bob!", "b") = true;
     * </pre>
     *
     * @param str    待判断的字符串
     * @param subStr 被包含的字符串
     * @return true 包含； false 不包含 。
     */
    public static boolean contains(String str, String subStr) {
        if (str == null || subStr == null) {
            return false;
        }
        return str.indexOf(subStr) > -1;
    }

    /**
     * 判断用delimiter分隔的str中是否包含subStr.
     * <p>
     * <pre>
     * StrUtils.contains(null, "b", ",") = false;
     * StrUtils.contains("a,b,c", null, "") = false;
     * StrUtils.contains("a,b,c", "b", null) = false;
     * StrUtils.contains("a,bob,c", "b", ",") = false;
     * StrUtils.contains("a,b,c", "b", ",") = true;
     * </pre>
     *
     * @param str       待分割的字符串
     * @param delimiter 分隔符
     * @param subStr    被包含的字符串
     * @return true 包含；false 不包含
     */
    public static boolean contains(String str, String delimiter, String subStr) {
        if (str == null || subStr == null || delimiter == null) {
            return false;
        }
        String[] splitStr = split(str, delimiter);
        if (splitStr.length > 0) {
            for (int i = 0; i < splitStr.length; i++) {
                if (subStr.equals(splitStr[i])) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 参数非null判断，返回第一个非null的对象的toString()，全部为null时，返回空字符串.
     * <p>
     * <pre>
     * StrUtils.getFirstNonNullStr(null) = "";
     * StrUtils.getFirstNonNullStr(null, "a") = "a";
     * StrUtils.getFirstNonNullStr(null, "b", "a") = "b";
     * </pre>
     *
     * @param obj 待判断对象
     * @return String
     */
    public static String getFirstNonNullStr(Object... obj) {
        if (obj == null) {
            return BLANK_STRING;
        }
        for (int i = 0; i < obj.length; i++) {
            if (obj[i] != null) {
                return String.valueOf(obj[i]);
            }
        }
        return BLANK_STRING;
    }

    public static BigDecimal stringToBigDecimal(String str) {
        if (isEmpty(str)) {
            return null;
        }
        return new BigDecimal(str.trim());
    }

    public static Integer stringToInteger(String str) {
        if (isEmpty(str)) {
            return null;
        }
        return Integer.valueOf(str.trim());
    }

    public static BigDecimal divide(BigDecimal v1, BigDecimal v2) {
        if (v1 == null || v2 == null) {
            return null;
        }
        if (v2.compareTo(BigDecimal.ZERO) == 0) {
            return null;
        }
        return v1.divide(v2, 2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 方法描述：除法运算
     *
     * @param v1
     * @param v2
     * @param scale
     * @return String
     * 创建人：yyd
     * 创建时间：2019年6月10日 上午10:50:19
     */
    public static String divide(String v1, String v2, int scale) {
        if (scale < 0 || isEmpty(v1) || isEmpty(v2)) {
            return "0.00";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        if (b2.compareTo(new BigDecimal(0)) == 0) {
            return "0.00";
        }
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 对比差异
     *
     * @return
     */
    public static String getContrast(List<String> _a, List<String> _b) {
        // 注意：一定要使用创建对象的格式创建数组
        // 创建集合
        Collection realA = new ArrayList<String>(_a);
        Collection realB = new ArrayList<String>(_b);
        // 求交集
        realA.retainAll(realB);
        //log.info("交集结果：" + realA);
        Set result = new HashSet();
        // 求全集
        result.addAll(_a);
        result.addAll(_b);
        //log.info("全集结果：" + result);
        // 求差集：结果
        Collection aa = new ArrayList(realA);
        Collection bb = new ArrayList(result);
        bb.removeAll(aa);
        //log.info("最终结果：" + bb.toString().replace("[", "").replace("]", ""));
        return bb.toString().replace("[", "").replace("]", "");
    }


    public static BigDecimal BigDecimalADD(BigDecimal v, BigDecimal... arg) {
        if (v == null) {
            v = BigDecimal.ZERO;
        }
        BigDecimal sum = v;
        for (BigDecimal b : arg) {
            if (b == null) {
                b = BigDecimal.ZERO;
            }
            sum = sum.add(b).setScale(2, BigDecimal.ROUND_HALF_UP);
            ;
        }
        return sum;

    }

    /**
     * 方法描述：将double转成BigDecimal相除
     *
     * @param money 被除数
     * @param price 除数
     *              创建人：yang
     *              创建时间：2017年3月15日 下午3:13:03
     */
    public static BigDecimal bigDecimalDIV(BigDecimal money, BigDecimal price) {
        if (money == null && price == null) {
            return BigDecimal.ZERO;
        }
        if (price.equals(BigDecimal.ZERO)) {
            return BigDecimal.ZERO;
        }
        BigDecimal b1 =new BigDecimal(0);
        if(money!=null) {
           b1 = money.setScale(4, BigDecimal.ROUND_HALF_UP);
        }
        BigDecimal b2 = price.setScale(4, BigDecimal.ROUND_HALF_UP);
        
        BigDecimal doubleValue = b1.divide(b2, 4, RoundingMode.HALF_UP);
        return doubleValue;
    }


    public static String prepareCondition(String str) {
        StringBuilder sb = new StringBuilder();
        if (isEmpty(str)) {
            return "";
        }
        String[] strArr = str.split("/");

        if (isEmpty(strArr[0])) {
            strArr[0] = "%";
        }
        if (isEmpty(strArr[1])) {
            strArr[1] = "%";
        }
        if (isEmpty(strArr[2])) {
            strArr[2] = "%";
        }
        if (isEmpty(strArr[3])) {
            strArr[3] = "%";
        }
        sb.append("%").append(strArr[0]).append("/").append(strArr[1]).append("/").append(strArr[2]).append("/").append(strArr[3]);

        return sb.toString();
    }

    public static String getStageCondition(String str) {
        if (isEmpty(str)) {
            return "";
        }
        String[] strArr = str.split("/");
        String stage = strArr[0];
        if (isEmpty(stage)) {
            return "";
        }
        return stage;
    }

    public static String prepareOverCondition(String str, String versionType) {
        StringBuilder sb = new StringBuilder();
        if (isEmpty(str)) {
            return "";
        } else {
            String g = str.split("/")[1];
            String pt = str.split("/")[2];
            String p = str.split("/")[3];
            String b = str.split("/")[4];
            if (isEmpty(g) && isEmpty(pt) && isEmpty(p) && isEmpty(b)) {
                return "";
            } else {
                if (versionType.equals(VersionTypeEunm.INVESTMENT.getKey())) {
                    sb.append(g).append("/").append("null").append("/").append(pt).append("/").append(p);
                } else {
                    sb.append(g).append("/").append(pt).append("/").append(p).append("/").append(b);
                }
            }
        }
        return prepareCondition(sb.toString());
    }

    /**
     * 方法描述：将double转成BigDecimal向加
     *
     * @param money 被加数
     * @param price 加数
     *              创建人：yang
     *              创建时间：2017年3月15日 下午3:13:03
     */
    public static BigDecimal BigDecimalADD(BigDecimal money, BigDecimal price) {

        if (money != null && price != null) {
            BigDecimal b1 = money.setScale(4, BigDecimal.ROUND_HALF_UP);
            BigDecimal b2 = price.setScale(4, BigDecimal.ROUND_HALF_UP);
            BigDecimal doubleValue = b1.add(b2).setScale(4, BigDecimal.ROUND_HALF_UP);
            return doubleValue;
        } else if (money == null && price == null) {
            return new BigDecimal(0);
        } else if (money != null && price == null) {
            return money;
        } else if (money == null && price != null) {
            return price;
        } else {
            return price;
        }
    }

    /**
     * 方法描述：将double转成BigDecimal向乘
     *
     * @param money 被乘数
     * @param price 乘数
     *              创建人：yang
     *              创建时间：2017年3月15日 下午3:13:03
     */
    public static BigDecimal BigDecimalMUL(BigDecimal money, BigDecimal price) {
        if (money == null || price == null) {
            return new BigDecimal(0);
        }
        BigDecimal b1 = money.setScale(4, BigDecimal.ROUND_HALF_UP);
        BigDecimal b2 = price.setScale(4, BigDecimal.ROUND_HALF_UP);
        BigDecimal doubleValue = b1.multiply(b2).setScale(4, BigDecimal.ROUND_HALF_UP);
        return doubleValue;
    }


    /**
     * 根据名称返回排序值
     *
     * @param name
     * @return
     */
    public static int getSort(String name) {
        if (name.equals("全期")) {
            return 0;
        } else if (name.equals("一期")) {
            return 1;
        } else if (name.equals("二期")) {
            return 2;
        } else if (name.equals("三期")) {
            return 3;
        } else if (name.equals("四期")) {
            return 4;
        } else if (name.equals("五期")) {
            return 5;
        } else if (name.equals("六期")) {
            return 6;
        } else if (name.equals("七期")) {
            return 7;
        } else if (name.equals("八期")) {
            return 8;
        } else if (name.equals("九期")) {
            return 9;
        } else if (name.equals("十期")) {
            return 10;
        } else if (name.equals("十一期")) {
            return 11;
        } else {
            return 0;
        }
    }

    /**
     * 计算达成率=实际金额/计划金额*100%
     *
     * @param actual 实际金额
     * @param plan   计划金额
     * @return
     */
    public static String rateAchievement(BigDecimal actual, BigDecimal plan) {
        if (actual == null || plan == null) {
            return "0%";
        }
        if (actual.compareTo(BigDecimal.ZERO) == 0) {
            return "0%";
        }
        if (plan.compareTo(BigDecimal.ZERO) == 0) {
            return "0%";
        }
        BigDecimal result = actual.divide(plan, 4, BigDecimal.ROUND_HALF_UP);
        BigDecimal price = BigDecimalMUL(result, new BigDecimal(100));
        String rate = price.toString();
        return rate + "%";
    }

    /**
     * 根据全路径名称和新的项目名称
     *
     * @param name
     * @param newName
     * @return
     */
    public static String getNewOrgFullName(String name, String newName) {
        //String name="旭辉-旭辉集团-上海区域集团-嘉兴城市公司-项目团队-（供销存）嘉兴平湖市当湖街道1号地块";
        String[] names = name.split("-");
        int len = 0;
        for (int i = 0; i < names.length; i++) {
            if (i < names.length - 1) {
                len = len + names[i].length() + 1;
            }
        }
        newName = name.substring(0, len) + newName;
        return newName;
    }


    /**
     * 根据版本类型获取版本类型名称
     *
     * @param versionType
     * @return
     */
    public static String getVersionName(String versionType) {
        String versionName = "";
        if (versionType.equals(VersionTypeEunm.INVESTMENT.getKey())) {
            versionName = VersionTypeEunm.INVESTMENT.getValue();
        } else if (versionType.equals(VersionTypeEunm.WARPLAN.getKey())) {
            versionName = VersionTypeEunm.WARPLAN.getValue();
        } else if (versionType.equals(VersionTypeEunm.GETPRICE.getKey())) {
            versionName = VersionTypeEunm.GETPRICE.getValue();
        } else if (versionType.equals(VersionTypeEunm.DYNAMIC.getKey())) {
            versionName = VersionTypeEunm.DYNAMIC.getValue();
        } else if (versionType.equals(VersionTypeEunm.BUDGET.getKey())) {
            versionName = VersionTypeEunm.BUDGET.getValue();
        } else if (versionType.equals(VersionTypeEunm.PERMIT.getKey())) {
            versionName = VersionTypeEunm.PERMIT.getValue();
        } else if (versionType.equals(VersionTypeEunm.PRESURVEY.getKey())) {
            versionName = VersionTypeEunm.PRESURVEY.getValue();
        } else if (versionType.equals(VersionTypeEunm.ACTUALSURVEY.getKey())) {
            versionName = VersionTypeEunm.ACTUALSURVEY.getValue();
        }
        return versionName;
    }
	
	/*public static void main(String[] args) {
		
		log.info(StrUtils.getLocalYearMonth());
	}*/

    /**
     * 获取字符串指定位置层级名称
     *
     * @param str
     * @param index
     */
    public static String getStrOrgName(String str, int index) {
        if (isEmpty(str)) {
            return "";
        }
        String[] strArr = str.split("/");
        String stage = strArr[index];
        if (isEmpty(stage)) {
            return "";
        }
        return stage;
    }


    /**
     * 方法描述:减法
     * 创建人：jing
     * 创建时间：2017年3月15日 下午3:13:03
     */
    public static BigDecimal BigDecimalSub(BigDecimal money, BigDecimal price) {

        if (money != null && price != null) {
            BigDecimal b1 = money.setScale(4, BigDecimal.ROUND_HALF_UP);
            BigDecimal b2 = price.setScale(4, BigDecimal.ROUND_HALF_UP);
            BigDecimal doubleValue = b1.subtract(b2).setScale(4, BigDecimal.ROUND_HALF_UP);
            return doubleValue;
        } else if (money == null && price == null) {
            return new BigDecimal(0);
        } else if (money != null && price == null) {
            return money;
        } else {
            return price;
        }
    }

    /**
     * 获取字符串指定位置层级名称
     *
     * @param str
     * @param index
     */
    public static String getProductCode(String str, int index) {
        if (isEmpty(str)) {
            return "";
        }
        String[] strArr = str.split("\\.");
        String stage = strArr[index];
        if (isEmpty(stage)) {
            return "";
        }
        return stage;
    }

    /**
     * 相除
     *
     * @param v1
     * @param v2
     * @return
     */
    public static BigDecimal divideV2(BigDecimal v1, BigDecimal v2) {
        if (v1 == null || v2 == null) {
            return new BigDecimal(0);
        }
        if (v2.compareTo(BigDecimal.ZERO) == 0) {
            return new BigDecimal(0);
        }
        return v1.divide(v2, 2, BigDecimal.ROUND_HALF_UP);

    }

    /**
     * 当前时间减多少小时的时间戳
     *
     * @param hours
     * @return
     */
    public static String getTimeStamp(int hours) {
        LocalDateTime now = LocalDateTime.now().minusHours(hours);
        String localDate = now.toLocalDate().toString().replaceAll("-", "");
        String localTime = now.toLocalTime().toString().substring(0, 8).replaceAll(":", "") + "z";
        String day = localDate + localTime;
        return day;
    }

    /**
     * 当前时间减多少小时的时间戳
     *
     * @param hours
     * @return
     */
    public static String getTimeStamp2(int hours) {
        LocalDateTime now = LocalDateTime.now().minusHours(hours);
        String localDate = now.toLocalDate().toString().replaceAll("-", "");
        String localTime = now.toLocalTime().toString().substring(0, 8).replaceAll(":", "") + "Z";
        String day = localDate + localTime;
        return day;
    }

    /**
     * 计算返回的对比类型
     *
     * @return
     */
    public static int getPkType(List<String> names) {
        if (names.size() == 0) {
            return 0;
        }
        if (names.contains("投资版") && names.contains("战规版") && names.contains("动态版")) {
            return 1;
        } else if (names.contains("战规版") && names.contains("动态版")) {
            return 2;
        } else if (names.contains("投资版") && names.contains("动态版")) {
            return 3;
        } else if (names.contains("投资版") && names.contains("战规版")) {
            return 4;
        } else if (names.contains("投资版")) {
            return 5;
        } else if (names.contains("战规版")) {
            return 6;
        } else if (names.contains("预算版")) {
            return 7;
        } else if (names.contains("动态版")) {
            return 8;
        }
        return 0;
    }


    /**
     * 获取项目审批标题
     *
     * @return
     */
    public static String getSubject(String versionTypeCode, String projectName) {
        if (versionTypeCode.equals(VersionTypeEunm.BUDGET.getKey())) {
            //②预算版：【预算版签约计划】{项目名称}签约计划审批
            //示例：【预算版签约计划】北京锦安家园全周期签约计划审批
            return "【"+VersionTypeEunm.BUDGET.getValue() + "签约计划】" + projectName + "全周期签约计划审批";
        } else {
            //①非预算版：【签约计划】{项目名称}全周期签约计划审批；
            //示例：【签约计划】北京锦安家园全周期签约计划审批
            return "【签约计划】" + projectName + "全周期签约计划审批";
        }
    }

    public static String nvl(String str) {
        return str == null ? "" : str;
    }
    
    /**
     * 运算符(1无|2小于<|3小于等于≤)
     * @return
     */
    public static String getOperator(String str) {
    	if(StringUtils.isEmpty(str)) {
    		return "";
    	}
    	if(str.equals(Constants.ONE+"")) {
    		return "";
    	}
		if(str.equals(Constants.TWO+"")) {
		    return "<";		
		}
		if(str.equals(Constants.THREE+"")) {
			return "≤";
		}
		return "";
    }
    
    /**
	 * 根据条件类型返回不同的符号
	 * @param str
	 * @return
	 */
	public static String getConditionType(String str) {
		//条件类型(0默认 1或 2且)
		if(str.equals(Constants.ZERO+"")) {
			return "";
		}
		if(str.equals(Constants.ONE+"")) {
			return "||";
		}
		if(str.equals(Constants.TWO+"")) {
			return "&&";
		}
		return "";
	}
	
	/**
	 * 操作符计算
	 * 
	 * 
	 * @param str (a>=0&&a<=5) && (a>=3 && a<=6)
	 * @param value a的值
	 */
	public static boolean getEngineResult(String str,String value) {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.put("a", value);
		Object result = null;
		try {
			result = engine.eval(str);
		} catch (ScriptException e) {
			log.error("###### errorMsg: ", e);
		}
		return (boolean) result;
	}
	
	/**
	 * 获取状态的分组值
	 * @param str
	 * @return
	 */
	public static int getStatusGroup(String str) {
		//warning-预警标准-红色,remind-提醒标准-黄色,health-健康标准-绿色
		if(Constants.WARNING.equals(str)) {
			return Constants.ONE;
		}
		if(Constants.REMIND.equals(str)) {
			return Constants.TWO;
		}
		if(Constants.HEALTH.equals(str)) {
			return Constants.THREE;
		}
		return Constants.FOUR;
	}
	
	 /**
     * 运算符13 (1无|2大于 > | 3大于等于≥) 不用于计算
     * @return
     */
    public static String getOperator13(String str) {
    	if(StringUtils.isEmpty(str)) {
    		return "";
    	}
    	if(str.equals(Constants.ONE+"")) {
    		return "";
    	}
		if(str.equals(Constants.TWO+"")) {
		    return ">";		
		}
		if(str.equals(Constants.THREE+"")) {
			return "≥";
		}
		return "";
    }
    
    
    /**
     * 运算符13 (1无|2大于 > | 3大于等于>=) 用于计算
     * @return
     */
    public static String getOperator13Calculation(String str) {
    	if(StringUtils.isEmpty(str)) {
    		return "";
    	}
    	if(str.equals(Constants.ONE+"")) {
    		return "";
    	}
		if(str.equals(Constants.TWO+"")) {
		    return ">";		
		}
		if(str.equals(Constants.THREE+"")) {
			return ">=";
		}
		return "";
    }
    
    /**
     * 运算符24 (1无|2小于 < | 3小于等于<=) 用于计算
     * @return
     */
    public static String getOperator24Calculation(String str) {
    	if(StringUtils.isEmpty(str)) {
    		return "";
    	}
    	if(str.equals(Constants.ONE+"")) {
    		return "";
    	}
		if(str.equals(Constants.TWO+"")) {
		    return "<";		
		}
		if(str.equals(Constants.THREE+"")) {
			return "<=";
		}
		return "";
    }
    
    /**
     * 2个条件比较排序 红黄绿正序 金额倒叙
     * @param list
     */
    public static void compareOrder(List<OrgRoundVo>list) {
    	 Collections.sort(list, new Comparator<OrgRoundVo>() {
             public int compare(OrgRoundVo e1, OrgRoundVo e2) {
                 //先判断红黄绿
            	 int a = e1.getGroup() - e2.getGroup();
                 if (a != 0) {
                     return a > 0 ? 1 : -1;
                 }
                 //在判断金额
                 double b=(Double.parseDouble(e2.getQuotaVal().toString()) - Double.parseDouble(e1.getQuotaVal().toString()));
                 //a = (int) (Double.parseDouble(e2.getQuotaVal().toString()) - Double.parseDouble(e1.getQuotaVal().toString()));
                 //return a > 0 ? 1 : -1;
                 return b > 0 ? 1 : -1;
             }
         });
    }
    


	/**
	 * 验证是否是月底前4天
	 * 
	 * @return
	 */
	public static boolean isEndOfTheMonth() {
		Calendar calendar = Calendar.getInstance();
		// 当前+4天
		int localDate = Integer.parseInt(LocalDateTime.now().toLocalDate().toString().replace("-", "")) + 4;
		SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
		Date date = null;
		try {
			date = format.parse(localDate + "");
		} catch (ParseException e) {
			log.error("###### errorMsg: ", e);
		}
		calendar.setTime(date);
		int getDay = calendar.get(Calendar.DAY_OF_MONTH);
		if (getDay == calendar.getActualMaximum(Calendar.DAY_OF_MONTH)) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 去掉9个0 转换成double
	 * @return
	 */
	public static double bigDecimalParseDouble(BigDecimal big) {
        BigDecimal result = big.divide(new BigDecimal(100000000),2,BigDecimal.ROUND_HALF_UP);
        double value=Double.parseDouble(result.toString());
        return value;
	}

    /**
     * 是否数值，包括：整数和小数
     * @param number
     * @return
     */
    public static boolean isNumber(String number){
        if (org.apache.commons.lang3.StringUtils.isBlank(number)){
            return false;
        }
        return number.matches("-{0,1}\\d+(\\.){0,1}\\d*");
    }


    /**
     * 是否日期,只做格式校验，不验数值正确与否
     * @return
     */
    public static boolean isDate(String str){
        //yyyy-MM-dd HH:mm:ss 或 yyyy-MM-dd
        if (str.matches("\\d{4}-\\d{1,2}-\\d{1,2}( \\d{1,2}:\\d{1,2}:\\d{1,2}){0,1}")){
            return true;
        }
        //yyyy/mm/dd或 yyyy/mm/dd HH:mm:ss
        if (str.matches("\\d{4}/\\d{1,2}/\\d{1,2}( \\d{1,2}:\\d{1,2}:\\d{1,2}){0,1}")){
            return true;
        }
        return false;

    }
    
    /**
	 * BigDecimal除以1个亿转成double
	 * @param value
	 * @return
	 */
	public static double divideBillion(BigDecimal value) {
		double result=Double.parseDouble(value.divide(new BigDecimal(Constants.ONE_HUNDRED_MILLION), 2,BigDecimal.ROUND_HALF_UP).toString());
		return result;
	}
	
	public static String replaceStr(String str) {
		if(isEmpty(str)) {
			return "";
		}
		if(str.indexOf("/") > 0 ) {
			return str.replace("/", "_");
		}
		
		if(str.indexOf("\\") > 0 ) {
			return str.replace("\\", "_");
		}
		
		return "";
	}
}
